import $ from 'jquery';
import Url from './url'
let listen = {
    onPendencyAddNotify:{},//好友系统通知事件
    onApplyJoinGroupRequestNotify: {},//申请加群请求（只有管理员会收到）
    onApplyJoinGroupAcceptNotify: {},//申请加群被同意（只有申请人能够收到）
    onApplyJoinGroupRefuseNotify: {}, //申请加群被拒绝（只有申请人能够收到）
    onKickedGroupNotify: {}, //被管理员踢出群(只有被踢者接收到)
    onDestoryGroupNotify: {}, //群被解散(全员接收)
    onCreateGroupNotify: {}, //创建群(创建者接收)
    onInvitedJoinGroupNotify: {}, //邀请加群(被邀请者接收)
    onQuitGroupNotify: {}, //主动退群(主动退出者接收)
    onSetedGroupAdminNotify: {}, //设置管理员(被设置者接收)
    onCanceledGroupAdminNotify: {}, //取消管理员(被取消者接收)
    onRevokeGroupNotify: {}, //群已被回收(全员接收)
    onMsgNotify:null//监听新消息
};
// import  groupListen  from './group';
//数据请求方式
const postData = function(url, options) {
        let promise = new Promise(function(resolve, reject) {
            $.ajax({
                url: url,
                data: options,
                //headers: header,
                type: 'post',
                //contentType: 'application/json',
                success: function(data) {
                    data = typeof data == 'object' ? data : JSON.parse(data)
                    resolve(data);
                },
                error: function(res) {
                    console.log(res);
                    reject('网络连接错误')
                }
            })
        })
        return promise
    }
const getData = function(url, options = {}, isString = false) {
    let promise = new Promise(function(resolve, reject) {
        let ajaxOption = {
            url: url,
            data: options,
            type: 'get',
            success: function(data) {
                if (isString) {
                    resolve(data);
                    return
                }
                data = typeof data == 'object' ? data : JSON.parse(data)
                resolve(data);
            },
            error: function() {
                reject('网络连接错误')
            }
        }
    })
    return promise
}

function getQueryString(name) {
    var reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i');
    var r = window.location.search.substr(1).match(reg);
    if (r != null) {
        return r[2];
    }
    return null;
}


/**
 * 存储localStorage
 */
const setStore = (name, content) => {
	if (!name) return;
	if (typeof content !== 'string') {
		content = JSON.stringify(content);
	}
	window.localStorage.setItem(name, content);
}

/**
 * 获取localStorage
 */
const getStore = name => {
    if (!name) return;
    const dataStore = window.localStorage.getItem(name);
	return JSON.parse(dataStore);
}

/**
 * 删除localStorage
 */
const removeStore = name => {
	if (!name) return;
	window.localStorage.removeItem(name);
}
/* 控制台打印 */
const log = name => {
    console.log(name);
}
//公用消息转化
let transNews = (msg)=>{
    //console.log('msg',msg)
    msg.forEach((ele,index)=> {
        switch (ele.type) {
            case 'face':
                msg[index] = '[表情]'
                break;
            case 'img':
                msg[index] = '[图片]'
                break;
            case 'file':
                msg[index] = '[文件]'
                break;
            case 'audio':
                msg[index] = '[语音]';
                break;
            case 'position':
                msg[index] = '[地理位置]'
                break;
            case 'tip':
                msg[index] = '[群提示消息]'
                break;
            /*default:
                return ele
                break;*/
        }
    });
    console.log('dd',msg)
    return msg;
}

//公用登陆
function login(callback) {
    //登录前数据请求
    const AppId = getQueryString("AppId"),
          OpenId = getQueryString("OpenId");
    let checkLogin;
    if(!AppId&&!OpenId){
        if(localStorage.userLogin){
            checkLogin = getStore('userLogin');
        }else{
            alert('应用ID不能为空');
            return;
        }
    }else{
        checkLogin = {
            AppId: AppId,//"123456789",//必传 地址栏参数
            OpenId: OpenId//"QWERTYUIO"//必传 地址栏参数
            //"Identifier":"1234567890",
            //"UserType": 0
        };
        setStore('userLogin',checkLogin);
    }
    postData(Url.LoginUrl, checkLogin).then(
      data => {
        if (data.ErrorCode != 0) {
          alert(data.ErrorInfo);
          return;
        }
        console.log(data);
        let resultData = data.Result;
        let userMsg = resultData.UserSig;
        //公用登录主体开始
        //（独立模式）
        let sdkAppID = resultData.SdkAppId, //用户所属应用id,必填
          accountType = resultData.accountType, //用户所属应用帐号类型，必填
          identifier = userMsg.Identifier, //当前用户ID,必须是否字符串类型，必填
          userSig = userMsg.sig; //当前用户身份凭证，必须是字符串类型，必填
        //headurl = data.headurl;//当前用户默认头像，选填，如果设置过头像，则可以通过拉取个人资料接口来得到头像信息
        //'identifierNick':, //当前用户昵称，不用填写，登录接口会返回用户的昵称，如果没有设置，则返回用户的id
        // identifier = '68b01fbc186553e4';
        // userSig = 'eJxlj11PgzAARd-5FYRXjZRCGfNtdriRwKKRLdlTw-qBVSlNV0Ex-ncnLhHjfT0n9*Z*OK7remX*cFVR2r4qS*y75p577XrAu-yFWktGKktCw-5B-qal4aQSlpsRBgghCMDUkYwrK4U8G3FyAIE40CCJEQp5NDGP7JmMcz9V0aknmgXwjyLrERbpHmf3eJPxG0CHQXQziutVtNP1lt7hxl8UyfKiqtnLvNjFw77P**xxkalmWaJ*W6bY3CbcwgFmSqinAoTtXG3YKvf7zl-rdO1PJq1s*PlbABKIIEIT2nFzlK0aBQhOCgzBdzzn0-kCVOpe7w__';

        //当前用户身份
        let loginInfo = {
            sdkAppID: sdkAppID,
            identifier: identifier,
            accountType: accountType,
            userSig: userSig,
            headurl: ""
        };
        
        /*function onPendencyAddNotify(notify) {
              webim.Log.info("执行 未决添加 回调：" + JSON.stringify(notify));
              console.log(notify)
              //收到加好友申请，弹出拉取好友申请列表
             // getPendency(true);
              var typeCh = "[未决添加]";
              var pendencyList = notify.PendencyList;
              var content = "收到以下加好友申请：" + JSON.stringify(pendencyList);
              //addFriendSystemMsg(notify.Type, typeCh, content);
          }*/
          function onPendencyAddNotify(notify) {
            console.log('好友回调',notify);
            listen.onPendencyAddNotify = notify;
          } //未决增加
        //监听好友系统通知函数对象
        var onFriendSystemNotifys = {
          //"1": onFriendAddNotify, //好友表增加
          //"2": onFriendDeleteNotify, //好友表删除
          "3": onPendencyAddNotify //未决添加
          //"4": onPendencyDeleteNotify, //未决删除
          //"5": onBlackListAddNotify, //黑名单增加
          //"6": onBlackListDeleteNotify //黑名单删除
        };









        function onMsgNotify(newMsgList) {
            //console.log('newMsgList',newMsgList);
            console.log('commonYES');
            var sess, newMsg;
            //获取所有聊天会话
            var sessMap = webim.MsgStore.sessMap();
            for (var j in newMsgList) {//遍历新消息
                newMsg = newMsgList[j];
                //console.log('监听新消息',newMsg);
                //
                /*if(!selToID){//没有聊天对象
                    selToID=newMsg.getSession().id();
                    selType=newMsg.getSession().type();
                    selSess = newMsg.getSession();
                    var headUrl;
                    if(selType==webim.SESSION_TYPE.C2C){
                        headUrl=friendHeadUrl;
                    }else{
                        headUrl=groupHeadUrl;
                    }
                    addSess(selType,selToID, newMsg.getSession().name(), headUrl, 0, 'sesslist');//新增一个对象
                    setSelSessStyleOn(selToID);
                }
                if (newMsg.getSession().id() == selToID) {//为当前聊天对象的消息
                    //在聊天窗体中新增一条消息
                    //console.warn(newMsg);
                    addMsg(newMsg);
                }*/
                //msgList.push(newMsg.elems[0].content.text);
            }
            listen.onMsgNotify = newMsg;
            //消息已读上报，以及设置会话自动已读标记
            /*webim.setAutoRead(selSess, true, true);
        
            for (var i in sessMap) {
                sess = sessMap[i];
                if (selToID != sess.id()) {//更新其他聊天对象的未读消息数
                    if(!dateStart){
                        dateStart = new Date();
                    }
                    updateSessDiv(sess.type(), sess.id(), sess.name(), sess.unread());
                    console.debug(sess.id(),sess.unread());
                    dateEnd = new Date();
                }
            }*/
        }

        let onProfileSystemNotifys = {
            "1": onProfileModifyNotify//资料修改  
        };
        //监听资料系统通知函数对象
        function onProfileModifyNotify(notify) {
            webim.Log.info("执行 资料修改 回调："+JSON.stringify(notify));
            var typeCh = "[资料修改]";
            var profile,account,nick,sex,allowType,content;
            account=notify.Profile_Account;
            content = "帐号："+account+", ";
            for(var i in notify.ProfileList){
                profile=notify.ProfileList[i];
                switch(profile.Tag){
                    case 'Tag_Profile_IM_Nick':
                        nick=profile.ValueBytes;
                        break;
                    case 'Tag_Profile_IM_Gender':
                        sex=profile.ValueBytes;
                        break;
                    case 'Tag_Profile_IM_AllowType':
                        allowType=profile.ValueBytes;
                        break;
                    default:
                        webim.log.error('未知资料字段：'+JSON.stringify(profile));
                        break;
                }
            }
            content+="最新资料：【昵称】："+nick+",【性别】："+sex+",【加好友方式】："+allowType;
            console.log(content);
            //addProfileSystemMsg(notify.Type, typeCh, content);
        
            /*if(account!=loginInfo.identifier){//如果是好友资料更新
                //好友资料发生变化，需要重新加载好友列表或者单独更新account的资料信息
                getAllFriend(getAllFriendsCallbackOK);
            }*/
        }












        // 群组监听 start ------------------------------------------------------------------
        // --------------------------------------------------------------------------------
        // --------------------------------------------------------------------------------
        // --------------------------------------------------------------------------------


        //监听（多终端同步）群系统消息方法，方法都定义在receive_group_system_msg.js文件中
        //注意每个数字代表的含义，比如，
        //1表示监听申请加群消息，2表示监听申请加群被同意消息，3表示监听申请加群被拒绝消息
        let onGroupSystemNotifys = {
            "1": onApplyJoinGroupRequestNotify, //申请加群请求（只有管理员会收到）
            "2": onApplyJoinGroupAcceptNotify, //申请加群被同意（只有申请人能够收到）
            "3": onApplyJoinGroupRefuseNotify, //申请加群被拒绝（只有申请人能够收到）
            "4": onKickedGroupNotify, //被管理员踢出群(只有被踢者接收到)
            "5": onDestoryGroupNotify, //群被解散(全员接收)
            "6": onCreateGroupNotify, //创建群(创建者接收)
            "7": onInvitedJoinGroupNotify, //邀请加群(被邀请者接收)
            "8": onQuitGroupNotify, //主动退群(主动退出者接收)
            "9": onSetedGroupAdminNotify, //设置管理员(被设置者接收)
            "10": onCanceledGroupAdminNotify, //取消管理员(被取消者接收)
            "11": onRevokeGroupNotify, //群已被回收(全员接收)
            // "15": onReadedSyncGroupNotify, //群消息已读同步通知
            "255": onCustomGroupNotify, //用户自定义通知(默认全员接收)
            "12":onInvitedJoinGroupNotifyRequest//邀请加群(被邀请者接收,接收者需要同意)
        };


        // 加群申请
        function onApplyJoinGroupRequestNotify(notify) {
            
              console.log("yxs",notify);
              listen.onApplyJoinGroupRequestNotify = notify;
              // webim.Log.info("执行 加群申请 回调：" + JSON.stringify(notify));
              // var data = [];
              // var timestamp = notify.MsgTime;
              // notify.MsgTimeStamp = timestamp;
              // notify.MsgTime = webim.Tool.formatTimeStamp(notify.MsgTime);
              // data.push(notify);
              // loginInfo.listeners = 222;
              // console.log("福州");
              // $('#get_apply_join_group_pendency_table').bootstrapTable('append', data);
              // $('#get_apply_join_group_pendency_dialog').modal('show');
            
              // var reportTypeCh = "[申请加群]";
              // var content = notify.Operator_Account + "申请加入你的群";
              // addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, timestamp);
            }

            //监听 申请加群被拒绝 系统消息
            function onApplyJoinGroupRefuseNotify(notify) {
                webim.Log.info("执行 申请加群被拒绝 回调：" + JSON.stringify(notify));
                let reportTypeCh = "[申请加群被拒绝]";
                let content = notify.Operator_Account + "拒绝了你的加群申请，附言：" + notify.RemarkInfo;
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("被拒绝");
                log(data);
                log("被拒绝");
            }

            //监听 申请加群被同意 系统消息
            function onApplyJoinGroupAcceptNotify(notify) {
                webim.Log.info("执行 申请加群被同意 回调：" + JSON.stringify(notify));
                let reportTypeCh = "[申请加群被同意]";
                let content = notify.Operator_Account + "同意你的加群申请，附言：" + notify.RemarkInfo;
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("被同意");
                log(data);
                log("被同意");
            
            }

            //监听 被踢出群 系统消息
            function onKickedGroupNotify(notify) {
                webim.Log.info("执行 被踢出群  回调：" + JSON.stringify(notify));
                //刷新我的群组列表
                //getJoinedGroupListHigh(getGroupsCallbackOK);
                // deleteSessDiv(webim.SESSION_TYPE.GROUP,notify.GroupId);//在最近的联系人列表删除可能存在的群会话
                let reportTypeCh = "[被踢出群]";
                let content = "你被管理员" + notify.Operator_Account + "踢出该群";
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("被踢出群");
                log(data);
                log("被踢出群");
            }

            //监听 解散群 系统消息
            function onDestoryGroupNotify(notify) {
                webim.Log.info("执行 解散群 回调：" + JSON.stringify(notify));
                //刷新我的群组列表
                //getJoinedGroupListHigh(getGroupsCallbackOK);
                // deleteSessDiv(webim.SESSION_TYPE.GROUP,notify.GroupId);//在最近的联系人列表删除可能存在的群会话
                let reportTypeCh = "[群被解散]";
                let content = "群主" + notify.Operator_Account + "已解散该群";
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("群被解散");
                log(data);
                log("群被解散");
            }

            //监听 创建群 系统消息
            function onCreateGroupNotify(notify) {
                webim.Log.info("执行 创建群 回调：" + JSON.stringify(notify));
                let reportTypeCh = "[创建群]";
                let content = "你创建了该群";
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("你创建了该群");
                log(data);
                log("你创建了该群");
            }

            //监听 被邀请加群 系统消息
            function onInvitedJoinGroupNotify(notify) {
                alert(111);
                webim.Log.info("执行 被邀请加群  回调: " + JSON.stringify(notify));
                //刷新我的群组列表
                //getJoinedGroupListHigh(getGroupsCallbackOK);
                let reportTypeCh = "[被邀请加群]";
                let content = "你被管理员" + notify.Operator_Account + "邀请加入该群";
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("被邀请加群");
                log(data);
                log("被邀请加群");
            }

            //监听 主动退群 系统消息
            function onQuitGroupNotify(notify) {
                webim.Log.info("执行 主动退群  回调： " + JSON.stringify(notify));
                // deleteSessDiv(webim.SESSION_TYPE.GROUP,notify.GroupId);//在最近的联系人列表删除可能存在的群会话
                let reportTypeCh = "[主动退群]";
                let content = "你退出了该群";
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("主动退群");
                log(data);
                log("主动退群");
            }

            //监听 被设置为管理员 系统消息
            function onSetedGroupAdminNotify(notify) {
                webim.Log.info("执行 被设置为管理员  回调：" + JSON.stringify(notify));
                let reportTypeCh = "[被设置为管理员]";
                let content = "你被群主" + notify.Operator_Account + "设置为管理员";
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("被设置为管理员");
                log(data);
                log("被设置为管理员");
            }

            //监听 被取消管理员 系统消息
            function onCanceledGroupAdminNotify(notify) {
                webim.Log.info("执行 被取消管理员 回调：" + JSON.stringify(notify));
                let reportTypeCh = "[被取消管理员]";
                let content = "你被群主" + notify.Operator_Account + "取消了管理员资格";
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("被取消管理员");
                log(data);
                log("被取消管理员");
            }

            //监听 群被回收 系统消息
            function onRevokeGroupNotify(notify) {
                console.info("执行 群被回收 回调： %s", JSON.stringify(notify));
                //刷新我的群组列表
                // getJoinedGroupListHigh(getGroupsCallbackOK);
                let reportTypeCh = "[群被回收]";
                let content = "该群已被回收";
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, 
                                notify.GroupName, content, notify.MsgTime);
                                log("该群已被回收");
                                log(data);
                                log("该群已被回收");
            }

            //监听 被邀请加群(用户需要同意) 系统消息
            function onInvitedJoinGroupNotifyRequest(notify) {
                alert(111);
                let timestamp = notify.MsgTime;
                notify.MsgTimeStamp = timestamp;
                notify.MsgTime = webim.Tool.formatTimeStamp(notify.MsgTime);
                data.push(notify);
                // $('#get_apply_join_group_pendency_dialog').modal('show');
               let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, timestamp);
               log("被邀请加群(用户需要同意)");
               log(data);
               log("被邀请加群(用户需要同意)");
            }

            //监听 群资料变化 群提示消息
            function onGroupInfoChangeNotify(notify) {
                alert(111);
                log("群资料变化");
                webim.Log.info("执行 群资料变化 回调： " + JSON.stringify(notify));
                let groupId = notify.GroupId;
                let newFaceUrl = notify.GroupFaceUrl;//新群组图标, 为空，则表示没有变化
                let newName = notify.GroupName;//新群名称, 为空，则表示没有变化
                let newOwner = notify.OwnerAccount;//新的群主id, 为空，则表示没有变化
                let newNotification = notify.GroupNotification;//新的群公告, 为空，则表示没有变化
                let newIntroduction = notify.GroupIntroduction;//新的群简介, 为空，则表示没有变化
                log("群资料变化");
                log(11);
                log("群资料变化");
                // if (newName) {
                //     updateSessNameDiv(webim.SESSION_TYPE.GROUP,groupId,newName);
                // }
                // if (newFaceUrl) {
                //     updateSessImageDiv(webim.SESSION_TYPE.GROUP,groupId,newFaceUrl);
                // }
            }

            //监听 用户自定义 群系统消息
            function onCustomGroupNotify(notify) {
                webim.Log.info("执行 用户自定义系统消息 回调：" + JSON.stringify(notify));
                var reportTypeCh = "[用户自定义系统消息]";
                var content = notify.UserDefinedField;//群自定义消息数据
                let data = addGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
                log("用户自定义系统消息");
                log(data);
                log("用户自定义系统消息");
            }

            //增加一条群组系统消息
            function addGroupSystemMsg(type, typeCh, group_id, group_name, msg_content, msg_time) {
                var data = [];
                data.push({
                    "ReportType": type,
                    "ReportTypeCh": typeCh,
                    "GroupId": webim.Tool.formatText2Html(group_id),
                    "GroupName": webim.Tool.formatText2Html(group_name),
                    "MsgContent": webim.Tool.formatText2Html(msg_content),
                    "MsgTime": webim.Tool.formatTimeStamp(msg_time)
                });
                return data;
                // $('#get_my_group_system_msgs_table').bootstrapTable('append', data);
                //$('#get_my_group_system_msgs_dialog').modal('show');
            }

        // 群组监听 end ------------------------------------------------------------------
        // --------------------------------------------------------------------------------
        // --------------------------------------------------------------------------------
        // --------------------------------------------------------------------------------


















        //监听事件
        let listeners = {
          //"onConnNotify": onConnNotify,//监听连接状态回调变化事件,必填

          //"jsonpCallback": jsonpCallback,//IE9(含)以下浏览器用到的jsonp回调函数，

          "onMsgNotify": onMsgNotify,//监听新消息(私聊，普通群(非直播聊天室)消息，全员推送消息)事件，必填

          //"onBigGroupMsgNotify": onBigGroupMsgNotify,//监听新消息(直播聊天室)事件，直播场景下必填

          "onGroupSystemNotifys": onGroupSystemNotifys,//监听（多终端同步）群系统消息事件，如果不需要监听，可不填

          "onGroupInfoChangeNotify": onGroupInfoChangeNotify,//监听群资料变化事件，选填

          "onFriendSystemNotifys": onFriendSystemNotifys, //监听好友系统通知事件，选填

          "onProfileSystemNotifys": onProfileSystemNotifys,//监听资料系统（自己或好友）通知事件，选填

          //"onKickedEventCall" : onKickedEventCall,//被其他登录实例踢下线

          //"onC2cEventNotifys": onC2cEventNotifys,//监听C2C系统消息通道
        };
        //监听连接状态回调变化事件
        /*var onConnNotify = function (resp) {
              var info;
              switch (resp.ErrorCode) {
                  case webim.CONNECTION_STATUS.ON:
                      webim.Log.warn('建立连接成功: ' + resp.ErrorInfo);
                      break;
                  case webim.CONNECTION_STATUS.OFF:
                      info = '连接已断开，无法收到新消息，请检查下你的网络是否正常: ' + resp.ErrorInfo;
                      alert(info);
                      webim.Log.warn(info);
                      break;
                  case webim.CONNECTION_STATUS.RECONNECT:
                      info = '连接状态恢复正常: ' + resp.ErrorInfo;
                      alert(info);
                      webim.Log.warn(info);
                      break;
                  default:
                      webim.Log.error('未知连接状态: =' + resp.ErrorInfo);
                      break;
              }
          };*/
        let options = {
          isAccessFormalEnv: true,
          isLogOn: false
        };
        function webimLogin() {
          webim.login(
            loginInfo,
            listeners,
            options,
            resp => {
              loginInfo.identifierNick = resp.identifierNick; //设置当前用户昵称
              loginInfo.headurl = resp.headurl; //设置当前用户头像
              //console.log(resp);
              listen = Object.assign(loginInfo,listen);
              //console.log('555',listen)
              callback && callback(listen);
            },
            err => {
              alert(err.ErrorInfo);
            }
          );
        }
        webimLogin();
        //公用登录主体结束
      },
      data => {
       
        alert("网络连接错误");
      }
    );
}

const Client = {
    login,
    getQueryString,
    setStore,
    getStore,
    removeStore,
    log,
    postData,
    getData,
    transNews
}
export default Client